/*
 * KissC JavaScript Library v1.2
 * http://KissCss.com
 * Copyright 2011, nodejs.js@gmail.com
 * Date: 2011-12-15
*/ 

( function(){

var KissC= ( function() {

var KissC = function( selector , context ) {
	// The KissC object is the meaning of 'Keep It Simple Silly!Css!'
	 //定义选择器的实例
	return KissC.prototype.init( selector , context ); 
},
userAgent = window.navigator.userAgent.toLowerCase();


/*
*KissC的原型属性和方法
*/
KissC.prototype= {
	version : "1-2", 
	constructor : KissC,
	length :0,
	//定义选择器构造器
	init : function( selector , context ) {
		//设置选择器的默认值为document ,如果为字符串，去除左右的多余空格
		//selector = selector || document; 
		selector ="string" === typeof selector ? selector.trim() : ( selector || document );
		//设置上下文索引默认值为document
		context = context || document; 

		var elems = KissCQuery.exec( selector, context ), elemsLen;
		//console.log( " -- "+ elems.constructor );
		if( elems == null ){
			this.length = 0;
		}else if( elems.nodeType ){
			this[0] = elems;
			this.length = 1;
		}else if( KissC.Tools.isArray( elems ) ){
			//alert( " Is array ");
			elemsLen = this.length = elems.length;
			for( var i=0; i< elemsLen; i++ ){
				this[ i ] = elems[ i ];
			}
		}
		//返回KissC
		return this;
	},  
	size : function(){  
		return this.length;  
	}
};

!String.prototype.trim && ( String.prototype.trim = function() { return this.replace( KissCQuery.WHITESPACES, "" ); } );

/*
*KissC选择器引擎 
*支持CSS3
*/

KissCQuery = {
	ISSIMPLE : /^(#|\.)?[\w\u00c0-\uFFFF_-]+$/, 	//判断是否简单选择器(只有id,Class 或tagname，不包括*)
	WHITESPACES :  /^\s+|\s+$/g,                       //去掉当前字符串两端的空格
	SPACE : /\s*([\s>~+,])\s*/g,							//去空格
	ATTRVALUES : /=(["'])([^'"]*)\1]/g, 				//替换引号括起来的属性值
	ATTR : /\[\s*([\w\u00c0-\uFFFF_-]+)\s*(?:(\S?\=)\s*(.*?))?\s*\]/g, // 用于替换属性选择器
	IMPLIEDALL : /([>\s~\+,]|^)([#\.\[:])/g, 	// 用于补全选择器
	//BEGINIDAPART : /^(?:\*#([\w\u00c0-\uFFFF_-]+))/, 	// 用于分离开头的id选择器
	STANDARD : /^[>\s~\+:]/, 	// 判断是否标准选择器(以空格、>、~或+开头)
	STREAM : /[#\.>\s\[\]:~\+]+|[^#\.>\s\[\]:~\+]+/g,	// 用于把选择器表达式分离成操作符/操作数 数组
	ISINT : /^\d+$/,														// 判断是否整数
	PSEUDOSEQ : /\(([^\(\)]*)\)$/g, 									// 用于匹配伪类选择器最后的序号
	tempAttrValues : [],														// 临时记录引号/双引号间的属性值
	tempAttrs: [], 															// 临时记录属性表达式

	isNaN : window.isNaN,
	/// 事件Id属性名
	idName : "KissCssEventId",


	exec : function( selector, context ){
		var t = this,
			selectors, // selector数组
			selCount, // selector数组长度
			i, j, 		// 循环变量
			temp, 		// 临时搜索结果
			matchs, 	// 操作符/操作数 数组
			streamLen, 	// 操作符/操作数 数组长度
			token, 		// 操作符
			filter, 	// 操作数
			result; 	// 最后结果

		
		if ( "" === selector ) { return; }

		//selector 为DOM 对象
		if( selector.nodeType ) return selector;

		//只有id,Class 或tagname，不包括*
		if( t.ISSIMPLE.test( selector ) ){
			if( 0 === selector.indexOf("#") && typeof context.getElementById !== "undefined" ){
				return context.getElementById( selector.substr( 1 ) );
			}else if( 0 === selector.indexOf(".") ){
				return t.getElemByClass( selector.substr( 1 ), context );
			}else if( typeof context.getElementsByTagName !== "undefined" ){
				return KissC.Tools.makeArray( context.getElementsByTagName( selector ) );
			}
		}

		//支持 querySelectorAll
		/*if( document.querySelectorAll && context.nodeType ){
			return KissC.Tools.makeArray( context.querySelectorAll( selector ) );
		}*/
		
		// 转换成数组，统一处理
		context = context.nodeType ? [context] : KissC.Tools.makeArray( context );
		

		selectors = selector.replace(t.SPACE, "$1")		// 去空白
						.replace(t.ATTRVALUES, t.analyzeAttrValues)	// 替换属性值
						.replace(t.ATTR, t.analyzeAttrs)	// 替换属性选择符
						.replace(t.IMPLIEDALL, "$1*$2")		// 添加必要的"*"(例如.class1 => *.class1)
						.split(",");	// 分离多个选择器
		selCount = selectors.length;

		//console.log( selectors );

		i = -1; result = [];

		while ( ++i < selCount ) {
			// 重置上下文
			temp = context;
			//console.log("**"+context);//document

			selector = selectors[i];
			//console.log( selector );

			// 处理后续的部分
			if (selector !== "") {
				if ( !t.STANDARD.test( selector ) ) {
					//console.log( selector );
					selector = " " + selector;
					//console.log( selector );
					//alert(selector);
				}
				//alert( selector );//div[]0

				// 分离换成字符串数组，从0开始双数是操作符，单数是操作数(例如 " *.class1" => [" ", "*", ".", "class1"])
				matchs = selector.match( t.STREAM ) || [];
				streamLen = matchs.length;
				j = 0;
				
				//console.log( matchs );//[" ", "div", "[]", "0"]
				//console.log( streamLen );//4

				while ( j < streamLen ) {
					token = matchs[ j++ ];//操作符
					filter = matchs[j++];//操作数
					//console.log( token );
					//console.log( filter );
					//temp=document
					temp = t.operators[token] ? t.operators[token](temp, filter) : [];
					//console.log( t.operators[token] );
					//console.log( t.operators[token](temp, filter) );
					//console.log( temp );
					//console.log( token );
					//console.log( filter );
					//console.log( t.operators[token](temp, filter) );
					if ( 0 === temp.length ) {
						break;
					}
				}
			}
			return KissC.Tools.merge( result, temp );
		}


	},

	//通过Class选择元素
	getElemByClass : function( searchClass, context ,tag ){
		if( document.getElementsByClassName ){
			return  KissC.Tools.makeArray( document.getElementsByClassName( searchClass ) );
		} else {
			tag = tag || "*";
			var classes = searchClass.split(" "),
			elements =  ( context === "*" && context.all ) ? context.all : context.getElementsByTagName( tag ),
			patterns = [], returnElements = [], current,match;
			var i = classes.length;
			for( var m=0; m<i; m++ ) patterns.push( new RegExp("(^|\\s)" + classes[ m ] + "(\\s|$)") );
			var j = elements.length;
			for(var n=0; n<j; n++ ){
				current = elements[ n ];
				match = false;
				for( var k=0, kl=patterns.length; k<kl; k++ ){
					match = patterns[ k ].test( current.className );
					if ( !match )  break;
				}
				if ( match )  returnElements.push( current );
			}
			return returnElements;   
		}   
	},

	// 属性值替换处理函数
	analyzeAttrValues : function($1, $2, $3) {
		//alert( "=" + (KissCQuery.tempAttrValues.push($3) - 1) + "]" );
		return "=" + (KissCQuery.tempAttrValues.push($3) - 1) + "]";
	},

	// 属性替换处理函数
	analyzeAttrs : function($1, $2, $3, $4) {
		return "[]" + (KissCQuery.tempAttrs.push([$2, $3, $4]) - 1);
	},

	getElemsByAttribute : function(context, filter) {
		//console.log( context );
		//console.log( filter );
		var result = [], elem, i = 0,
			check = this.attrOperators[filter[1] || ""],
			attrValue = "~=" === filter[1] ? " " + filter[2] + " " : filter[2];
			//console.log("~=" === filter[1]);
		if (check) {
			while (elem = context[i++]) {
				check(this.getAttribute(elem, filter[0]), attrValue) && result.push(elem);
			}
		}
		return result;
	},

	// 获取元素属性
	getAttribute : function(elem, attrName) {
		var trueName = this.attrMap[attrName] || attrName, 
		//IE 下elem[trueName] 可以直接获取到元素的属性值
		attrValue = elem[trueName];
		if ("string" !== typeof attrValue) {
			if ("undefined" !== typeof elem.getAttributeNode) {
				attrValue = elem.getAttributeNode(attrName);
				attrValue = undefined == attrValue ? attrValue : attrValue.value;
			} else if (elem.attributes) {		// for IE5.5
				attrValue = String(elem.attributes[ attrName ]);
			}
		}
		return null == attrValue ? "" : attrValue;
	},
	
	// 搜索指定位置的某标签名元素
	// @param {Array} 上下文
	// @param {String} 第一个元素相对位置
	// @param {String} 下一个元素相对位置
	// @param {String} 标签名
	// @param {Number} 最多进行多少次查找
	// @return {Array} 搜索结果
	getElemsByTagName : function(context, first, next, tagName, limit) {
		var result = [], i = -1, len = context.length, elem, counter, tagNameUpper;
		tagName !== "*" && (tagNameUpper = tagName.toUpperCase());
		while (++i < len) {
			elem = context[i][first]; counter = 0;
			while (elem && (!limit || counter < limit)) {
				if (1 === elem.nodeType) {
					(elem.nodeName.toUpperCase() === tagNameUpper || !tagNameUpper) && result.push(elem);
					counter++;
				}
				elem = elem[next];
			}
		}

		return result;
	},

	// 获取不重复的元素id
	// @param {HTMLElement} 元素
	// @return {Number} id
	generateId : function(elem) {
		var idName = this.idName, id;
		try {
			id = elem[idName] = elem[idName] || new Number(++this.id);
		} catch (e) {
			id = elem.getAttribute(idName);
			if (!id) {
				id = new Number(++this.id);
				elem.setAttribute(idName, id);
			}
		}
		return id.valueOf();
	},

	// 根据指定顺序检查上下文父元素的第n个子元素是否该上下文元素
	// @param {Array} 上下文
	// @param {Number} 序号
	// @param {String} 第一个元素相对位置
	// @param {String} 下一个元素相对位置
	// @return {Array} 搜索结果
	checkElemPosition : function( context, seq, first, next ) {
		var result = [];
		if ( !this.isNaN( seq ) ) {
			var len = context.length, i = -1,
				cache = {},		// 节点缓存
				parent, id, current, child;
				
			while ( ++i < len ) {
				parent = context[i].parentNode;		// 找到父节点
				id = this.generateId( parent );		// 为父节点生成一个id作为缓存键值
				
				if (undefined === cache[id]) {	// 如果缓存中没有，则重新寻找父元素的第N个子元素
					current = 0;			// 重置当前序号
					child = parent[first];	// 第一个元素
					while ( child ) {
						1 === child.nodeType && current++;	// 序号加1
						if ( current < seq ) {
							child = child[next];	// 还没到指定序号，继续找
						} else {
							break;	// 已经到指定序号，中断循环
						}
					}
					cache[id] = child || 0;		// 记下本次搜索结果
				} else {
					child = cache[id];
				}
				context[i] === child && result.push(context[i]);	// 搜索结果与节点相符
			}
		}
		return result;
	},
	
	// 获取特定位置的元素
	// @param {Array} 上下文
	// @param {Number} 第一个位置
	// @param {Number} 下一个位置递增量
	// @return {Array} 过滤结果
	getElemsByPosition : function(context, first, next) {
		var i = first, len = context.length, result = [];
		while (i >= 0 && i < len) {
			result.push(context[i]);
			i += next;
		}
		return result;
	},

	// 属性名映射
	attrMap : {
		"class" : "className",
		"for" : "htmlFor"
	},

	// 操作符
	operators : {
		// 后代选择符
		" " : function(context, tagName) {
			var len = context.length;
			if (1 === len) {
				return context[0].getElementsByTagName(tagName);
			} else {
				var result = [], i = -1;
				while (++i < len) {
					KissC.Tools.merge(result, context[i].getElementsByTagName(tagName));
				}
				return result;
			}
		},
		// 属性选择符
		"[]" : function(context, filter) {
			filter = KissCQuery.tempAttrs[filter];
			//alert( filter );
			if (filter) {
				if (KissCQuery.ISINT.test(filter[2])) {
					filter[2] = KissCQuery.tempAttrValues[filter[2]];
				}
				return KissCQuery.getElemsByAttribute(context, filter);
			} else {
				return context;
			}
		},

		// 类名选择器
		"." : function(context, className) {
			return KissCQuery.getElemsByAttribute(context, ["class", "~=", className]);
		},

		// id选择符
		"#" : function(context, id) {
			return KissCQuery.getElemsByAttribute(context, ["id", "=", id]);
		},

		// 子元素选择符
		">" : function(context, tagName) {
			return KissCQuery.getElemsByTagName(context, "firstChild", "nextSibling", tagName);
		},

		// 同级元素选择符
		"+" : function(context, tagName) {
			return KissCQuery.getElemsByTagName(context, "nextSibling", "nextSibling", tagName, 1);
		},

		// 同级元素选择符
		"~" : function(context, tagName) {
			return KissCQuery.getElemsByTagName(context, "nextSibling", "nextSibling", tagName);
		},

		// 伪类选择符
		":" : function(context, filter) {
			var seq;
			if (KissCQuery.PSEUDOSEQ.test(filter)) {
				seq = parseInt(RegExp.$1);
				filter = RegExp.leftContext;
			}
			return KissCQuery.pseOperators[filter] ? KissCQuery.pseOperators[filter](context, seq) : [];
		}

	},

	attrOperators : {
		// 是否包含指定属性值
		"" : function(value) { return value !== ""; },
		// 是否与指定属性值相等
		"=" : function(value, input) { return input === value; },
		// 是否包含指定属性值
		"~=" : function(value, input) { return (" " + value + " ").indexOf(input) >= 0; },
		// 是否与指定属性值不等
		"!=" : function(value, input) { return input !== value; },
		// 属性值是否以某段字符串开头
		// 属性值是否以某段字符串结尾
		"$=" : function(value, input) { return value.substr(value.length - input.length) === input; },
		// 属性值是否包含某段子字符串
		"*=" : function(value, input) { return value.indexOf(input) >= 0; }
	},

	// 伪类选择符
	pseOperators : {

		// 获取第一个子元素
		"first-child" : function(context) {
			return KissCQuery.checkElemPosition(context, 1, "firstChild", "nextSibling");
		},

		// 获取第n个子元素
		"nth-child" : function(context, seq) {
			return KissCQuery.checkElemPosition(context, seq, "firstChild", "nextSibling");
		},

		// 获取最后一个子元素
		"last-child" : function(context) {
			return KissCQuery.checkElemPosition(context, 1, "lastChild", "previousSibling");
		},

		// 获取倒数第n个子元素
		"nth-last-child" : function(context, seq) {
			return KissCQuery.checkElemPosition(context, seq, "lastChild", "previousSibling");
		},
		
		// 获取第奇数个元素
		"odd" : function(context) {
			return KissCQuery.getElemsByPosition(context, 0, 2);
		},
		
		// 获取第偶数个元素
		"even": function(context) {
			return KissCQuery.getElemsByPosition(context, 1, 2);
		},
		
		// 获取第N个元素前的元素
		"lt" : function(context, seq) {
			return KissCQuery.getElemsByPosition(context, seq - 1, -1);
		},
		
		// 获取第N个元素后的元素
		"gt" : function(context, seq) {
			return KissCQuery.getElemsByPosition(context, seq + 1, 1);
		}
	}


}

/*
*KissC的拷贝继承方式 
*/

KissC.extend = function ( child , parent ){
	for (var i in parent) {   
		if (typeof parent[i] === 'object') {   
			//child[i] = (parent[i].constructor === Array) ? [] : {};  
			KissC.extend(child[i],parent[i]);  
		} else {  
			child[i] = parent[i]; 
		}
	}  
	return child;
};


/*
*KissC的静态方法
*/
KissC.extend( KissC, {
	each : function( Arr, callback, args ) {  
		for(var i = 0; i < Arr.length; i++ ) {  
			callback.call( Arr[i], args );  
		}  
		return Arr;  
	}
});


/*
*KissC的DOM处理模块
*/
KissC.extend( KissC.prototype , KissC.Dom = {
	//DOMready
	ready : function(handler){  
		var isReady=false, readyList=[], timer;
		if( document.addEventListener ) {  
			document.addEventListener("DOMContentLoaded",function(){  
				//清除加载函数
				document.removeEventListener( "DOMContentLoaded", arguments.callee, false );
				// W3C 下的 DOMContentLoaded方法 ,页面 HTML, JS加载完成后立即执行,判断加载状态标志 isReady = true;
				deleteListener();
			}, false );  
		} else if ( document.attachEvent ) {  
			document.attachEvent( "onreadystatechange", function( ) {  
				if( (/loaded|compete/).test( document.readyState ) ) 
					// 在 IE 体系下 ,通过 onreadystatechange 方法监听文档的加载过程,如果加载状态变为 loaded 或者 compete,执行isReady = true;
					deleteListener();             
			} );          
			if( window == window.top ){  
				timer = setInterval( function( ) {  
					try {  
						isReady || document.documentElement.doScroll( 'left' );  
					} catch( e ){ return; }  
					deleteListener();  
				}, 5 );          
			}
		}  
		if( isReady ){
			handler.call( document );  
		}else{
			readyList.push( function() { 
				return handler.call( this );
			});  
		}

		var applyReadyList=function( ){
			for( var i = 0; i < readyList.length; i++ ) { 
				readyList[i].apply( document );          
			}  
			readyList = null; 
		};

		var deleteListener = function( ) {  
			if ( isReady ) return;
			isReady = true;
			applyReadyList.call( window );
			if( document.removeEventListener ){
				document.removeEventListener( "DOMContentLoaded", deleteListener, false );
			} else if (document.attachEvent){
				document.detachEvent( "onreadystatechange", deleteListener );
				if( window == window.top ){
					clearInterval( timer );
					timer = null;
				}  
			}  
		};
	},
	
	//通过索引获取结果中的对象
	get : function ( v ){
		return this[ v ];
	},
	
	//设置或返回对象的HTML
	html : function ( v ) {
		KissC.each(this,function( v ){  
            this.innerHTML = v;  
        }, v );
		return this;
	},
	
	//设置或获取对象的css属性
	css : function( prop ){
		if(typeof(prop)==='string'){
			if(!this[0].currentStyle){
				return eval("document.defaultView.getComputedStyle(this[0],null)."+prop);
			}else{
				return eval("this[0].currentStyle."+prop);
			}
		}else if( typeof( prop ) === 'object' ){
			KissC.each(this,function( prop ){  
	            var cssT='';
				for(var name in prop){
					//IE7 bug:filter 滤镜要求 hasLayout=true 方可执行（否则没有效果）
					if(name == "opacity" && !+"\v1"){
						if (!this.el.currentStyle || !this.el.currentStyle.hasLayout) this.el.style.zoom = 1;
						name = "filter";
						if(!!window.XDomainRequest){
							prop[name] ="progid:DXImageTransform.Microsoft.Alpha(style=0,opacity="+prop[name]*100+")";
						}else{
							prop[name] ="alpha(opacity="+prop[name]*100+")";
						}
					}
					cssT +=name + ":" + prop[name]+';';	
				}
				this.style.cssText +=cssT;
	        }, prop );
			return this;
		}
	},
	
	//设置或返回对象的value
	val : function( v ){
		if( typeof v == 'undefined')
			return this[0].value;
		else
			KissC.each( this, function( v ){
				this.value = v;
			}, v );
	},
	
	//设置或返回对象的nodeValue
	text : function(){
		var t,e;
		t = "", e = this[0],
		// 如果传入点是元素，则继续遍历其子元素，否则假定它是一个数组
		e = e.childNodes ? e.childNodes : e; 
		for( var i = 0; i < e.length; i++ ){
			t += e[i].nodeType ==1 ? e[i].nodeValue : "";
		}
		// 返回匹配的文本
		return t; 
	},
	
	//设置或返回对象的属性
	attr : function( prop ){
		if( typeof prop === 'string'){
			//console.log( this );
		}
		//alert(KissCQuery.attrMap.class);
	}
} );

/*
*KissC的工具函数
*/
KissC.Tools = {
	//是否为数字
	isNumber : function ( v ) {
		var reg = /^([0-9])$/;
		return reg.test(v);
	},
	
	//是否是函数
	//在safari下typeof NodeList也返回function
	isFunction : function( fn ) {
		 return !!fn 
			 && typeof fn != "string" 
			 && !fn.nodeName 
			 && fn.constructor != Array 
			 && /^[\s[]?function/.test( fn + "" );  
	},
	
	//是否为空对象 {}
	isEmptyObject: function( o ) {
        for (var p in o) {
            return false;
        }
        return true;
    },
    
    /*
    *  判断对象否为纯粹的对象字面量 
    *  对于通过字面量定义的对象和new Object的对象返回true，new Object时传参数的返回false  
    */
    isPlainObject : function(obj){
		//判断是否非window和DOM对象的对象，
		if ( !obj || obj.toString() !== "[object Object]" || obj.nodeType || obj.setInterval ) {
			return false;
		}
		//constructor是对创建对象的函数的引用（指针）。对于 Object 对象，该指针指向原始的 Object() 函数
		//判断obj是否具有isPrototypeOf属性，isPrototypeOf是挂在Object.prototype上的。通过字面量或自定义类（构造器）创建的对象都会继承该属性方法
		if ( obj.constructor && !obj.hasOwnProperty("constructor") && !obj.constructor.prototype.hasOwnProperty("isPrototypeOf") ) {
			return false;
		}
		var key;
		for ( key in obj ) {}
		return key === undefined || obj.hasOwnProperty(key);
	},
	
	//是否是数组
	isArray : function( o ){
		return o && typeof o==='object' && typeof o.length==='number' && typeof o.splice==='function';
	},
	
	//连接数组，将second数组追加到first之后
	merge : function(first, second) {
		var i = second.length, pos = first.length;
		while (--i >= 0) {
			first[pos + i] = second[i];
		}
		return first;
	},
	
	//是否是IE
	ieIE : !-[1,],
	
	//是否不是IE
	notIE : -[1,],
	
	//生成数组
	makeArray : function( o ){
		var a = [];
		for(var i = 0; i < o.length; i++ ){
			a.push(o[i]);
		}
		return a;
	},
	
	// 检测一个元素在一个数组中是否存在.如果存在返回索引值.如果不存在则返回-1.
	indexOf: function(elem, arr) {
        for (var i = 0, len = arr.length; i < len; ++i) {
            if (arr[i] === elem) {
                return i;
            } 
        }
        return -1;
     },
         


	//判断对象是否存在与数组中
	inArray : function( obj, array ){
		if ( !array ) {
			return false;
		}
		for ( var i = 0, length = array.length; i < length; i++ ) {
			if ( array[ i ] === obj ) {
				return true;
			}
		}
		return false;
	}
	

};

/*
*KissC的事件处理
*/
KissC.Event = {
	createEvents : function(){},
	hasEvent : function(){},
	detachEvent : function(){},
	fireEvent : function(){},
	addEvent :function( elm, evType, fn, useCapture ) {     
		if ( elm.addEventListener ) {
			// DOM 2.0   
			elm.addEventListener( evType, fn, useCapture ); 
			return true;     
		}else if ( elm.attachEvent ) {
			var r = elm.attachEvent( 'on' + evType, function() {
	            fn.apply( elm, arguments );
			});
			return r;     
		}else {
			//DOM 0
			elm['on' + evType] = fn;
		}
	}
};


/*
* 给 DOM 对象添加鼠标事件
* 鼠标事件
* 键盘事件
* UI事件
* 表单事件
* 加载和错误事
*/
KissC.each(("blur focus focusin focusout load resize scroll unload click dblclick " +
								"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
								"change select submit keydown keypress keyup error").split(" "), function(type) {
		// 这里的 this 指代的是以上数组中的一个成员值
		type=this.toString(); 
		//给KissC.prototype 绑定方法 增加事件
		KissC.prototype[ type ] = function( fn ){ 
			// 这里的this 指向 KissC.prototype
			KissC.each( this, function() { 
				//这里的 this 指向 KissC对象的属性名为 0-n 的成员
				KissC.Event.addEvent( this, type, fn );
			},fn );
			return this;
		};
});


/*
*KissC的AJAX模块
* @ method GET || POST
* @ url 请求的页面
* @ timeout 超时的时间
* @ onComplete 交互完成回调函数
* @ onError 交互失败的回调函数
* @ onSuccess 交互成功的回调函数
* @ data POST传递的数据
* @ dataType HTML || XML 
* @ async 异步或者同步
* @ username 用户名
* @ password 密码
* @ cache 是否缓存
*/

KissC.ajax ={
	// XMLHttpRequest 对象
	xhr : function( ) {
		return KissC.Tools.notIE ? new XMLHttpRequest() : new ActiveXObject("Microsoft.XMLHTTP");
	},
	
	// -串行化一列数据。支持4种不同的对象；
	// -若是字符串或 null 就直接将其返回
	// -表单输入的元素的数组
	// -键/值对的散列表
	// -返回值为串行后的字符串
	serialize : function( a ){
		var s = [];
		// 若传入的参数是数组，假定他们是表单元素的数组
		if( typeof a === "string" || a===null || a===undefined ) {
			return a;
		} else if( a.constructor === undefined || a.constructor == Array ) { //串行化表单元素
			// 一下的串行化表单元素的浏览器兼容性还没解决
			return ;
			for( var i = 0, a=KissC.Tools.makeArray(a); i < a.length; i++){
				s.push( a[i].name + "=" + encodeURIComponent( a[i].value) );
			}
		} else {// 否则，假设这个为键值对象
			for(var j in a) {
				s.push( j + "=" + encodeURIComponent( a[j] ) );
			}
		}
		return s.join( "&" );
	},
	
	// 服务器状态判断
	httpSuccess : function(r) {
		try {
			//alert( location.protocol == "file:" );
			// 如果得不到服务器状态，且我们在请求本地文件，设为成功
			return !r.status && location.protocol == "file:" || 
			// 所有 200 - 300 之间的状态码都表示成功
			( r.status >= 200 && r.status < 300 ) ||
			// 文档未作修改设为成功
			r.status == 304 ||
			// Safari 在文档未修改时返回空状态
			navigator.userAgent.indexOf("Safari") >= 0 
				&& typeof r.status == "undefined";
		}catch (e){}
		// 若检查状态失败，就设置请求为失败
		return false;
	},
	
	// 服务器返回数据类型检测
	httpDataType : function( r, type ){
		// 获取content-type的首部
		var ct = r.getResponseHeader("content-type");
		// 若没哟设置默认的类型，判断服务器返回的是否是 XML 形式
		var data = !type && ct && ct.indexOf("xml") >= 0;
		// 若是获得 XML 文档对象，否则返回文本内容
		data = type == "xml" || data ? r.responseXML : r.responseText;
		// 若指定类型是"script"，则以javascript形势返回为本
		if( type === "script")
			eval.call( window, data );
		return data;
	},
	
	send : function( options ){
		var xhr, requestDone, errorText;
		// 设置 options 的默认值
		options = {
			// HTTP 请求的类型
			method : options.method ? options.method.toUpperCase() : "POST",
			// 请求的 URL
			url : options.url || "",
			// 请求的超时时间
			timeout : options.timeout || 5000,
			// 请求 失败，成功，完成时执行的函数(不管是否成功还是失败都会调用)
			onComplete : options.onComplete || function(){},
			onError : options.onError || function(){},
			onSuccess : options.onSuccess || function(){},
			// 服务器将返回的数据类型，这个默认值用于判断服务器返回的数据类型，并作相应动作
			data : KissC.ajax.serialize( options.data ) || "",
			dataType : options.dataType || "HTML",
			// 异步还是同步，默认是异步(true)
			async : null == options.async ? true : Boolean(options.async),
			username : options.username || "",
			password : options.password || "",
			cache : options.cache || true
		};
		// 创建请求对象
		xhr = new KissC.ajax.xhr();
		//初始化一个 5 秒后执行的回调函数，如果请求尚未完成的话，将请求取消
		setTimeout( function() {
			requestDone = true;
		}, options.timeout );
		// 文档状态监听函数，在文档的状态改变时被调用
		xhr.onreadystatechange = function() {
			// 保持等待，直到数据完全加载，并保证请求并未超时
			if( xhr.readyState==4 && !requestDone ) {
				if( KissC.ajax.httpSuccess( xhr ) ) {
					//以服务器返回的数据作为参数调用成功回调函数
					options.onSuccess( KissC.ajax.httpDataType( xhr, options.dataType ) );
				} else {
					errorText = xhr.status == "404" ? "Not Found" : "Unknown Error";
					options.onError.call( this, errorText);
				}
				//调用完成回调函数
				options.onComplete();
				// 避免内存泄漏，清理文档
				xhr = null;
			} else if ( requestDone == true && xhr.readyState==3 ){
				errorText = "请求超时";
				options.onError.call( this, errorText );
			}
		};
		// 初始化异步 method 的请求
		xhr.open( options.method, options.url, options.async ,options.username, options.password );
		// 设置 Content-type 首部，告知服务器如何解析我们发送的数据
		xhr.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
		// 保证浏览器发送的串行化数据长度正确
		// 基于 Mozilla 的浏览器有时处理这个会碰到问题
		//if( xhr.overrideMimeType)
			//xhr.setRequestHeader("Connection","close");
		// 与服务器建立连接
		xhr.send(options.data);
		return xhr;
	},
	
	// 加载json
	getJSON : function( url,JSONcallback ){
		var _script = document.createElement( 'script' );
		_script.src = url;
		document.body.appendChild( _script );
		if( KissC.Tools.isIE ){
			_script.onreadystatechange = function(){
				if( this.readyState == 'complete'){
					JSONcallback();
				}
			};
		}else{
			_script.onload = function(){
				JSONcallback();
			};
		}
	}
};


/*
*KissC的Cookie处理
* 设置Cookie
* 获取Cookie
* 删除Cookie 
*/
KissC.Cookie = {
	Set : function( c_name, value, exdays ){
		var exdate = new Date();
		exdate.setDate( exdate.getDate() + exdays );
		var c_value=escape(value) + ( ( exdays == null ) ? "" : "; expires=" + exdate.toUTCString() );
		document.cookie = c_name + "=" + c_value;	
	},
	Get : function( name ){
		 var arr = document.cookie.match( new RegExp("(^| )"+name+"=([^;]*)(;|$)"));
		 if(arr != null) return unescape( arr[2] ); return null;	
	},
	Delete : function( name ){
		var exp = new Date();
		exp.setTime(exp.getTime() - 1);
		var cval=KissC.Cookie.Get(name);
		if(cval!=null) document.cookie= name + "="+cval+";expires="+exp.toGMTString();
	}
};

KissC.data = {
	//提取网址的参数
	parseQueryString : function( url ){
		var data = url.slice( url.indexOf('?')+1 ), obj = {}, arr = data.split('&'), temp;
		for(i in arr){
			temp = arr[ i ].split( '=' );
			obj[ temp[0] ] = temp[1];
		}
		return obj;
	},
	
	//接受一个JSON字符串，返回解析后的对象
	parseJSON : function( str ){
		if( typeof JSON === 'undefined'){
			return (new Function("return " + str))(); 
		}else{
			return JSON.parse( str );
		}
	},
	
	//将JSON对象转换成字符串
	stringify : function( obj ){
		if( typeof JSON === 'undefined'){
			//ie7,ie6不支持全局JSON
			var type = Object.prototype.toString.call(obj).slice(8,-1) , rs;
	        switch(type){
	            case "Undefined" : 
	            case "Null" : 
	            case "Number" :  
	            case "Boolean" : 
	            case "Date" : 
	            case "Function" :
	            case "Error" :
	            case "RegExp" :  rs = obj ; break;
	            case "String" : rs = '"' + obj + '"'; break;
	            case "Array" :
	                rs = "";
	                for(var i=0,len=obj.length;i<len;i++){
	                    rs+=_toStr(obj[i])+",";
	                }
	                rs = "[" + rs.slice(0,-1) + "]";
	                break;
	            case "Object" :
	                rs = [];    
	                for(var k in obj){
	                    rs.push('"' + k.toString() + '":' + this.stringify(obj[k]));
	                }
	                rs = "{" + rs.join(",") + "}";
	                break;
	        }
	        return rs;
			
		}else{
			//Firefox，chrome，opera，safari，ie9，ie8支持JSON全局对象的方法
			return JSON.stringify( obj );
		}
	},
	
	// xml对象转换成 JSON 数据格式
	xmlToJson : function( xml ){
		var obj = {};
		//操作属性
		if (xml.nodeType == 1) {
			if (xml.attributes.length > 0) {
			obj["@attributes"] = {};
				for (var j = 0; j < xml.attributes.length; j++) {
					var attribute = xml.attributes.item(j);
					obj["@attributes"][attribute.nodeName] = attribute.nodeValue;
				}
			}
		} else if (xml.nodeType == 3 ) {
				obj = xml.nodeValue;
		}
		//操作子对象
		if (xml.hasChildNodes()) {
			for(var i = 0; i < xml.childNodes.length; i++) {
				var item = xml.childNodes.item(i);
				var nodeName = item.nodeName;
				if (typeof(obj[nodeName]) == "undefined") {
					obj[nodeName] = arguments.callee(item);
				} else if (typeof(obj[nodeName].length) == "undefined") {
						var old = obj[nodeName];
						obj[nodeName] = [];
						obj[nodeName].push(old);
						obj[nodeName].push( arguments.callee( item ));
				}
			}
		}
		// 删除回车字符文本节点
		for( i in obj){
			if( typeof obj[i] === 'string' && obj[i].charCodeAt(0) == 10 ){
				delete obj[i];
			}
		}
		return obj;
	},
	
	//将字符串解析成XML对象
	parseXML : function( data ){
		var xml, tmp;
		try {
			if ( window.DOMParser ) { // Standard
				tmp = new DOMParser();
				xml = tmp.parseFromString( data , "text/xml" );
			} else { // IE
				xml = new ActiveXObject( "Microsoft.XMLDOM" );
				xml.async = "false";
				xml.loadXML( data );
			}
		} catch( e ) {
			xml = undefined;
		}
		if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
			xml = "Invalid XML: " + data;
		}
		return xml;
	}
	

}




/*
* KissC的浏览器检测对象
* 判断是否为指定的某个浏览器
* 返回浏览器名称
*/
KissC.browser = {
	chrome: /webkit/.test( userAgent ) && /chrome/.test( userAgent ),
	safari: /webkit/.test( userAgent ) && !(/chrome/.test( userAgent )),
	opera: /opera/.test( userAgent ),
	msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
	mozilla: /mozilla/.test(userAgent)&&!/(compatible|webkit)/.test(userAgent),
	showBrowser : function(){
		if( this.msie ) return "Internet Explore";
		else if( this.chrome ) return "Chrome";
		else if( this.mozilla ) return "Mozilla Firefox";
		else if( this.opera ) return "Opera";
		else if( this.safari ) return "Safari";
	}
};


/*
* KissC的日期处理对象 
*/
KissC.date = {
	UnixTimestamp : function( t ){
		t = t || (new Date());
		return t.valueOf();
	},
	dateFormat : function( format, timeString ){

	}
};



/*
* KissC 的动画对象 
*/
KissC.extend( KissC.prototype , KissC.animate = { 
	run : function( el, from, to,speed){
		var h = from, time = 15, i = 1, r,
		s = ( ( from - to ) < 0 ) ? 1 : (-1);
		switch( speed ){
			case "slow":
				r = 5;
				break;
			case "fast":
				r = 2;
				break;
			case "normal":
				r = 3;
				break;
			default :
				r = 3;
				break;
		}
		if( $( el ).css('display') == 'none'){
			el.style.display = '';
		}
		(function() {
			h = (s > 0 && h + s > to) || ( s < 0 && h + s < to ) ? to : ( h + s );
			if( ++i % r == 0 && i > r ){
				time = ( time - 1 < 0 ) ? 5 : ( time - 1 );
				s = ( s > 0 ) ? ( s + 1 ) : ( s - 1 ); 
			}
			el.style.height = h +'px';
			if( ( s > 0 && h < to ) || ( s < 0 && h > to ) ){
				setTimeout( arguments.callee, time );
			}
			else{
				el.style.height = to + 'px';
				if( to == 0 ){
					el.style.display = 'none';
				}
			}
		})();
	},
	height : function( from, to, speed ){
		KissC.animate.run( this[0], from, to, speed );
	},
	width : function(){}
});






return ( window.KissC =window.kissc = window.$ = $ = KissC );
})();


})( window );//将window对象作为参数传给匿名函数